/* Create the 7 points (only x,y coords) used to draw a tooth */
struct point p[7];
- /* Calculate needed sin/cos for varius angles */
+ /* Calculate needed sin/cos for various angles */
sincos(i * 2.0 * G_PI / teeth + da * 0, &s[0], &c[0]);
sincos(i * 2.0 * M_PI / teeth + da * 1, &s[1], &c[1]);
sincos(i * 2.0 * M_PI / teeth + da * 2, &s[2], &c[2]);
priv->LightSourcePosition_location = glGetUniformLocation(program, "LightSourcePosition");
priv->MaterialColor_location = glGetUniformLocation(program, "MaterialColor");
- /* Set the LightSourcePosition uniform which is constant throught the program */
+ /* Set the LightSourcePosition uniform which is constant throughout the program */
glUniform4fv(priv->LightSourcePosition_location, 1, priv->LightSourcePosition);
/* make the gears */
extern void fontify (const char *format, GtkTextBuffer *buffer);
static void
-populate_text (gboolean hilight)
+populate_text (gboolean highlight)
{
GtkWidget *textview;
GtkTextBuffer *buffer;
buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_set_text (buffer, content, (int)content_len);
- if (hilight)
+ if (highlight)
fontify ("c", buffer);
textview = gtk_text_view_new ();
{ FALSE, 56925, "Normal", "Gtkcalender size" },
{ FALSE, 56221, "Normal", "Selectable label needs right-click copy menu" },
{ TRUE, 50939, "Normal", "Add shift clicking to GtkTextView" },
- { FALSE, 6112, "Enhancement","netscape-like collapsable toolbars" },
+ { FALSE, 6112, "Enhancement","netscape-like collapsible toolbars" },
{ FALSE, 1, "Normal", "First bug :=)" },
};
(GdkRGBA [4]) { BLACK, BLACK, BLACK, BLACK });
/* Next, draw the hour hand.
- * We do this using tranforms again: Instead of computing where the angle
+ * We do this using transforms again: Instead of computing where the angle
* points to, we just rotate everything and then draw the hand as if it
* was :00. We don't even need to care about am/pm here because rotations
* just work.
/*
* Finally, we define the type. The important part is adding the paintable
- * interface, so GTK knows that this object can indeed be drawm.
+ * interface, so GTK knows that this object can indeed be drawn.
*/
G_DEFINE_TYPE_WITH_CODE (GtkColor, gtk_color, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
{
int i;
- /* Show only if the name maches every needle */
+ /* Show only if the name matches every needle */
for (i = 0; search_needle[i]; i++)
{
if (!demo->title)
*
* Shows widgets in static positions over a main widget.
*
- * The overlayed widgets can be interactive controls such
+ * The overlaid widgets can be interactive controls such
* as the entry in this example, or just decorative, like
* the big blue label.
*/
gtk_image_clear (GTK_IMAGE (image));
}
-/* Thie is called once a drag operation has ended (successfully or not).
+/* This is called once a drag operation has ended (successfully or not).
* We want to undo what we did in drag_begin() above and react
* to a potential move of the peg.
*/
network-transmit=The icon used when data is being transmitted, while the computing device is connected to a network
network-receive=The icon used when data is being received, while the computing device is connected to a network
network-idle=The icon used when no data is being transmitted or received, while the computing device is connected to a network
-network-error=The icon used when an error occurs trying to intialize the network connection of the computing device
+network-error=The icon used when an error occurs trying to initialize the network connection of the computing device
network-offline=The icon used when the computing device is disconnected from the network
[weather]
object-flip-horizontal=The icon for the action to flip an object horizontally
object-flip-vertical=The icon for the action to flip an object vertically
object-rotate-left=The icon for the rotate left action performed on an object
-object-rotate-right=The icon for the rotate rigt action performed on an object
+object-rotate-right=The icon for the rotate right action performed on an object
insert-image=The icon for the insert image action of an application
insert-link=The icon for the insert link action of an application
insert-object=The icon for the insert object action of an application
modem=The icon used for modem devices
multimedia-player-apple-ipod-touch=
network-vpn=
-pda=This is the fallback icon for Personal Digial Assistant devices. Primary use of this icon is for PDA devices connected to the PC. Connection medium is not an important aspect of the icon. The metaphor for this fallback icon should be a generic PDA device icon
+pda=This is the fallback icon for Personal Digital Assistant devices. Primary use of this icon is for PDA devices connected to the PC. Connection medium is not an important aspect of the icon. The metaphor for this fallback icon should be a generic PDA device icon
phone-apple-iphone=
uninterruptible-power-supply=
emblem-default=The icon used as an emblem to specify the default selection of a printer for example
coding style to be used for the GTK source code. It was strongly
inspired by Clutter's `CODING_STYLE`.
-Coding style is a matter of consistency, readability and maintainance;
+Coding style is a matter of consistency, readability and maintenance;
coding style is also completely arbitrary and a matter of taste. This
document will use examples at the very least to provide authoritative
and consistent answers to common questions regarding the coding style,
an action name and an action target with a single string.
In the case that the action target is a string with no unusual characters
-(ie: only alpha-numeric, plus '-' and '.') then you can use a detailed
+(ie: only alphanumeric, plus '-' and '.') then you can use a detailed
action name of the form "justify::left" to specify the justify action with
a target of left.
are linearly ordered.
Every widget has one or more of these CSS nodes, and determines their
-name, state, style classes and how they are layed out as children and
+name, state, style classes and how they are laid out as children and
siblings in the overall node tree. The documentation for each widget
explains what CSS nodes it has.
Even if GTK installs multiple header files, only the top-level `gtk/gtk.h`
header can be directly included by third-party code. The compiler will abort
-with an error if any othe header is directly included.
+with an error if any other header is directly included.
In a GTK application, the purpose of the main() function is to create a
GtkApplication object and run it. In this example a GtkApplication pointer
the size and layout of buttons.
The GtkBox is created with gtk_box_new() which takes a GtkOrientation
-enum as parameter. The buttons which this box will contain can either be layed
+enum as parameter. The buttons which this box will contain can either be laid
out horizontally or vertically. This does not matter in this particular case,
as we are dealing with only one button. After initializing box with the newly
created GtkBox, the code adds the box widget to the window widget using
<term>--force</term>
<term>-f</term>
<listitem><para>Overwrite an existing cache file even if it appears to be
- uptodate.</para></listitem>
+ up-to-date.</para></listitem>
</varlistentry>
<varlistentry>
They are used in places where a label is associated with a control,
and are indicated by underlining the letter in the label. As a special
case, inside menus (i.e. inside #GtkPopoverMenu), mnemonics can be
- trigered without the modifier.
+ triggered without the modifier.
Key bindings
: Key bindings are specific to individual widgets, such as Ctrl-C or
Ctrl-V in an entry copy to or paste from the clipboard. They are only
The abstract base class GtkContainer for general containers has been
removed. The former subclasses are now derived directly from GtkWidget,
and have class-specific add() and remove() functions.
-The most noticable change is the use of gtk_box_append() or gtk_box_prepend()
+The most noticeable change is the use of gtk_box_append() or gtk_box_prepend()
instead of gtk_container_add() for adding children to GtkBox, and the change
to use container-specific remove functions, such as gtk_stack_remove() instead
of gtk_container_remove(). Adding a child in a ui file with <child> still works.
GTK now supports a more versatile -gtk-icon-filter instead. Replace
-gtk-icon-effect: dim; with -gtk-icon-filter: opacity(0.5); and
--gtk-icon-effect: hilight; with -gtk-icon-filter: brightness(1.2);.
+-gtk-icon-effect: highlight; with -gtk-icon-filter: brightness(1.2);.
### Don't use -gtk-icon-theme in your CSS
### Stop using APIs to query GdkSurfaces
A number of APIs for querying special-purpose windows have been removed,
-since these windows are no longer publically available:
+since these windows are no longer publicly available:
gtk_tree_view_get_bin_window(), gtk_viewport_get_bin_window(),
gtk_viewport_get_view_window().
gtk_list_store_set() and gtk_tree_store_set(), but can't read it back?
Both the #GtkTreeStore and the #GtkListStore implement the #GtkTreeModel
- interface. Consequentially, you can use any function this interface
+ interface. Consequently, you can use any function this interface
implements. The easiest way to read a set of data back is to use
gtk_tree_model_get().
| `METER` | Represents a value within a known range | #GtkLevelBar |
| `PROGRESS_BAR` | An element that display progress | #GtkProgressBar |
| `RADIO` | A checkable input in a group of radio roles | #GtkRadioButton |
-| `SCROLLBAR` | A graphical object controlling the scolling of content | #GtkScrollbar |
+| `SCROLLBAR` | A graphical object controlling the scrolling of content | #GtkScrollbar |
| `SEARCH_BOX` | A text box for entering search criteria | #GtkSearchEntry |
| `SEPARATOR` | A divider that separates sections of content or groups of items | #GtkSeparator |
| `SPIN_BUTTON` | A range control that allows seelcting among discrete choices | #GtkSpinButton |
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
```
-## Colums and cell renderers
+## Columns and cell renderers
Once the #GtkTreeView widget has a model, it will need to know how
to display the model. It does this with columns and cell renderers.
-Cache surfaces that are opened via shm_open inbetween updates.
+Cache surfaces that are opened via shm_open in between updates.
Handle implicit grabs when in broadway-server.c
keyboard focus handling
Add resize handling to js WM
Support window titles
_gdk_broadway_server_has_client is always FALSE, so resize don't work
Send reset events on client disconnect (button up, normal state. Maybe grab state reset?)
-rgba suport
+rgba support
shift-select in gedit doesn't work
backdrop mode
clean up /dev/shm on abrupt client exit
}
if (l == NULL)
- g_warning ("Got unexpected rountrip reply for id %d, tag %d\n", msg.roundtrip_notify.id, msg.roundtrip_notify.tag);
+ g_warning ("Got unexpected roundtrip reply for id %d, tag %d\n", msg.roundtrip_notify.id, msg.roundtrip_notify.tag);
else
{
BroadwayOutstandingRoundtrip *rt = l->data;
* between its serials and daemon serials for any outstanding requests.
*
* There is some additional complexity in that there may be multiple consecutive web browser
- * sessions, so we need to keep track of the last daemon serial used inbetween each web client
+ * sessions, so we need to keep track of the last daemon serial used in between each web client
* connection so that the daemon serials can be strictly increasing.
*/
guint8 recv_buffer[1024];
guint process_input_idle;
- GList *incomming;
+ GList *incoming;
};
struct _GdkBroadwayServerClass
reply = g_memdup (p, size);
p += size;
- server->incomming = g_list_append (server->incomming, reply);
+ server->incoming = g_list_append (server->incoming, reply);
}
if (p < end)
{
GList *l;
- for (l = server->incomming; l != NULL; l = l->next)
+ for (l = server->incoming; l != NULL; l = l->next)
{
BroadwayReply *reply = l->data;
server->process_input_idle = 0;
}
- while (server->incomming)
+ while (server->incoming)
{
- reply = server->incomming->data;
- server->incomming =
- g_list_delete_link (server->incomming,
- server->incomming);
+ reply = server->incoming->data;
+ server->incoming =
+ g_list_delete_link (server->incoming,
+ server->incoming);
if (reply->base.type == BROADWAY_REPLY_EVENT)
_gdk_broadway_events_got_input (server->display, &reply->event.msg);
reply = find_response_by_serial (server, serial);
if (reply)
{
- server->incomming = g_list_remove (server->incomming, reply);
+ server->incoming = g_list_remove (server->incoming, reply);
break;
}
if (timings)
{
timings->refresh_interval = 33333; /* default to 1/30th of a second */
- // This isn't quite right, since we've done a rountrip back too, can we do better?
+ // This isn't quite right, since we've done a roundtrip back too, can we do better?
timings->presentation_time = g_get_monotonic_time ();
timings->complete = TRUE;
*
* Returns: (transfer full) (nullable): a Cairo context to be used
* to draw the contents of the #GdkSurface. %NULL is returned
- * when @contet is not drawing.
+ * when @context is not drawing.
*/
cairo_t *
gdk_cairo_context_cairo_create (GdkCairoContext *self)
* be chosen to provide it.
*
* This allows an easy way to support providing data in different formats.
- * For example, an image may be provided by its file and by the iamge
+ * For example, an image may be provided by its file and by the image
* contents with a call such as
* |[<!-- language="C" -->
* gdk_content_provider_new_union ((GdkContentProvider *[2]) {
*
* Returns whether surfaces can reasonably be expected to have
* their alpha channel drawn correctly on the screen. Check
- * gdk_display_is_rgba() for wether the display supports an
+ * gdk_display_is_rgba() for whether the display supports an
* alpha channel.
*
* On X11 this function returns whether a compositing manager is
* gdk_display_is_rgba:
* @display: a #GdkDisplay
*
- * Returns wether surfaces on this @display are created with an
+ * Returns whether surfaces on this @display are created with an
* alpha channel.
*
* Even if a %TRUE is returned, it is possible that the
else
{
g_critical ("The surface %p is already being drawn by %s %p. "
- "You cannot draw s surface wih multiple contexts at the same time.",
+ "You cannot draw a surface with multiple contexts at the same time.",
priv->surface,
G_OBJECT_TYPE_NAME (priv->surface->paint_context), priv->surface->paint_context);
}
* a union of the region passed to that function and the area of the surface
* that the @context determined needs to be repainted.
*
- * If @context is not inbetween calls to gdk_draw_context_begin_frame() and
+ * If @context is not in between calls to gdk_draw_context_begin_frame() and
* gdk_draw_context_end_frame(), %NULL will be returned.
*
* Returns: (transfer none) (nullable): a Cairo region or %NULL if not drawing
* Once we do receive "frame drawn" events, smooth_cycle_start will track the vsync, and do so in a more stable
* way compared to frame_time. If we then no longer receive "frame drawn" events, smooth_cycle_start will again be
* simply advanced in increments of the refresh interval, but this time we are in sync with the vsync. If we start
- * receiving "frame drawn" events shortly after loosing them, then we should still be in sync.
+ * receiving "frame drawn" events shortly after losing them, then we should still be in sync.
*/
gint64 smooth_cycle_start = priv->smoothed_frame_time_base - priv->smoothed_frame_time_phase;
priv->min_next_frame_time = smooth_cycle_start + priv->smoothed_frame_time_period;
*
* Sets whether the #GdkGLContext should be forward compatible.
*
- * Forward compatibile contexts must not support OpenGL functionality that
+ * Forward compatible contexts must not support OpenGL functionality that
* has been marked as deprecated in the requested version; non-forward
* compatible contexts, on the other hand, must support both deprecated and
* non deprecated functionality.
* always produce the same output for the same snapshot.
*
* A #GdkPaintable may change its contents, meaning that it will now produce a
- * different output with the same snpashot. Once that happens, it will call
+ * different output with the same snapshot. Once that happens, it will call
* gdk_paintable_invalidate_contents() which will emit the
* #GdkPaintable::invalidate-contents signal. If a paintable is known to never
* change its contents, it will set the %GDK_PAINTABLE_STATIC_CONTENTS flag.
* Retrieves the bounds the toplevel is placed within.
*
* The bounds represent the largest size a toplevel may have while still being
- * able to fit within some type of boundery. Depending on the backend, this may
+ * able to fit within some type of boundary. Depending on the backend, this may
* be equivalent to the dimensions of the work area or the monitor on which the
* window is being presented on, or something else that limits the way a
* toplevel can be presented.
window_gdk.width += shadow_left + shadow_right;
window_gdk.height += shadow_top + shadow_bottom;
- /* Convert to quartz coordiantes */
+ /* Convert to quartz coordinates */
_gdk_macos_display_to_display_coords ([self gdkDisplay],
window_gdk.x,
window_gdk.y + window_gdk.height,
/* Current NSEvents that we've gotten from Cocoa but haven't yet converted
* to GdkEvents. We wait until our dispatch() function to do the conversion
- * since the conversion can conceivably cause signals to be emmitted
+ * since the conversion can conceivably cause signals to be emitted
* or other things that shouldn’t happen inside a poll function.
*/
static GQueue *current_events;
/* Flag when we've called nextEventMatchingMask ourself; this triggers
* a run loop iteration, so we need to detect that and avoid triggering
- * our "run the GLib main looop while the run loop is active machinery.
+ * our "run the GLib main loop while the run loop is active machinery.
*/
static int getting_events = 0;
gdk_surface_get_mapped (surface))
{
g_warning ("Surface %p is already mapped at the time of grabbing. "
- "gdk_seat_grab() should be used to simultanously grab input "
+ "gdk_seat_grab() should be used to simultaneously grab input "
"and show this popup. You may find oddities ahead.",
surface);
}
/* gdk_surface_is_destroyed() might already return TRUE for
* seat->keyboard_focus here, which would happen if we destroyed the
- * surface before loosing keyboard focus.
+ * surface before losing keyboard focus.
*/
stop_key_repeat (seat);
uint32_t _gdk_wayland_seat_get_implicit_grab_serial(GdkSeat *seat,
GdkEvent *event);
uint32_t _gdk_wayland_seat_get_last_implicit_grab_serial (GdkWaylandSeat *seat,
- GdkEventSequence **seqence);
+ GdkEventSequence **sequence);
struct wl_data_device * gdk_wayland_device_get_data_device (GdkDevice *gdk_device);
void gdk_wayland_device_set_selection (GdkDevice *gdk_device,
struct wl_data_source *source);
STARTFONT 2.1
COMMENT
COMMENT downloaded from http://webcvs.freedesktop.org/xorg/font/cursor-misc/cursor.bdf?revision=1.1
-COMMENT slighly edited by tml to correct a few gdk cursors on win32
+COMMENT slightly edited by tml to correct a few gdk cursors on win32
COMMENT
COMMENT Created by bitmaptobdf
FONT cursor
*/
GAsyncQueue *clipboard_render_queue;
- /* Window handle for the clipboard window tha we
+ /* Window handle for the clipboard window that we
* receive from the clipboard thread. We use that
* to wake up the clipboard window main loop by
* posting a message to it.
return FALSE;
}
- /* rows are always aligned on 4-byte boundarys */
+ /* rows are always aligned on 4-byte boundaries */
bmstride = size * 3;
if (bmstride % 4 != 0)
bmstride += 4 - (bmstride % 4);
}
else
{
- /* Go back to GetDeviceCaps() for Windows 8 and earler, or when we don't
+ /* Go back to GetDeviceCaps() for Windows 8 and earlier, or when we don't
* have a HMONITOR nor a HWND
*/
HDC hdc = GetDC (hwnd);
* drag window) in response to this, as all the functions
* that GDK could perform here are already handled by the
* OS driving the DnD process via DoDragDrop() call.
- * The LOCAL protocol, on the other hande, does a lot,
+ * The LOCAL protocol, on the other hand, does a lot,
* similar to what X11 backend does with XDND - it sends
* GDK_DRAG_LEAVE and GDK_DRAG_ENTER, emits GDK_DRAG_MOTION.
*
static enum_formats *enum_formats_new (GArray *formats);
/* Finds a GdkDrag object that corresponds to a DnD operation
- * which is currently targetting the dest_window
+ * which is currently targeting the dest_window
* Does not give a reference.
*/
GdkDrag *
return TRUE;
}
-/* Finds the HWND under cursor. Local DnD protcol
+/* Finds the HWND under cursor. Local DnD protocol
* uses this function, since local protocol is implemented
* entirely in GDK and cannot rely on the OS to notify
* drop targets about drags that move over them.
if ((windowpos->flags & SWP_HIDEWINDOW) &&
!GDK_SURFACE_DESTROYED (window))
{
- /* Make transient parent the forground window when window unmaps */
+ /* Make transient parent the foreground window when window unmaps */
impl = GDK_WIN32_SURFACE (window);
if (impl->transient_owner &&
typedef struct _GdkWin32DragUtilityData GdkWin32DragUtilityData;
/* This structure is deliberately designed to be
- * copyable with memcpy(), i.e. no pointers inside.
+ * copiable with memcpy(), i.e. no pointers inside.
*/
struct _GdkWin32DragUtilityData
{
* window only when there actually is drawing. To do that we use
* a technique (hack) suggested by Uli Schlachter - if we set
* a dummy "mime data" on the cairo surface (this facility is
- * used to attach JPEG data to an imager), then cairo wil flush
+ * used to attach JPEG data to an imager), then cairo will flush
* and remove the mime data before making any changes to the window.
*/
/* We initialize the alpha uniform here, since the default value is important.
- * We can't do it in the shader like a resonable person would because that doesn't
+ * We can't do it in the shader like a reasonable person would because that doesn't
* work in gles. */
for (i = 0; i < GL_N_PROGRAMS; i++)
{
RenderOpBuilder *builder)
{
/* This can still happen, even if the render nodes are created using
- * GtkSnapshot, so let's juse be safe. */
+ * GtkSnapshot, so let's just be safe. */
if (node_is_invisible (node))
return;
if (node->y > min_y) {
// raise min_y higher.
// we've accounted for all waste up to min_y,
- // but we'll now add more waste for everything we've visted
+ // but we'll now add more waste for everything we've visited
waste_area += visited_width * (node->y - min_y);
min_y = node->y;
// the first time through, visited_width might be reduced
/* For the blurred case we divide the rendering into 9 parts,
* 4 of the corners, 4 for the horizonat/vertical lines and
* one for the interior. We make the non-interior parts
- * large enought to fit the full radius of the blur, so that
+ * large enough to fit the full radius of the blur, so that
* the interior part can be drawn solidly.
*/
/* For the blurred case we divide the rendering into 9 parts,
* 4 of the corners, 4 for the horizonat/vertical lines and
* one for the interior. We make the non-interior parts
- * large enought to fit the full radius of the blur, so that
+ * large enough to fit the full radius of the blur, so that
* the interior part can be drawn solidly.
*/
*
* Checks two transforms for equality.
*
- * Returns: %TRUE if the two transforms peform the same operation.
+ * Returns: %TRUE if the two transforms perform the same operation.
**/
gboolean
gsk_transform_equal (GskTransform *first,
*
* If the parser matches the <url> token from the [CSS
* specification](https://drafts.csswg.org/css-values-4/#url-value),
- * consumes it, resolves the URL and resturns the resulting #GFile.
+ * consumes it, resolves the URL and returns the resulting #GFile.
* On failure, an error is emitted and %NULL is returned.
*
* Returns: (nullable) (transfer full): the resulting URL or %NULL on error
"aliases_ascii" : [
],
"keywords" : [
- "accomodation",
+ "accommodation",
"building",
"checkin",
"motel",
"clock1" : {
"unicode" : "1f550",
"unicode_alternates" : "",
- "name" : "clock face one oclock",
+ "name" : "clock face one o'clock",
"shortname" : ":clock1:",
"category" : "symbols",
"emoji_order" : "1013",
"clock2" : {
"unicode" : "1f551",
"unicode_alternates" : "",
- "name" : "clock face two oclock",
+ "name" : "clock face two o'clock",
"shortname" : ":clock2:",
"category" : "symbols",
"emoji_order" : "1014",
"clock3" : {
"unicode" : "1f552",
"unicode_alternates" : "",
- "name" : "clock face three oclock",
+ "name" : "clock face three o'clock",
"shortname" : ":clock3:",
"category" : "symbols",
"emoji_order" : "1015",
"clock4" : {
"unicode" : "1f553",
"unicode_alternates" : "",
- "name" : "clock face four oclock",
+ "name" : "clock face four o'clock",
"shortname" : ":clock4:",
"category" : "symbols",
"emoji_order" : "1016",
"clock5" : {
"unicode" : "1f554",
"unicode_alternates" : "",
- "name" : "clock face five oclock",
+ "name" : "clock face five o'clock",
"shortname" : ":clock5:",
"category" : "symbols",
"emoji_order" : "1017",
"clock6" : {
"unicode" : "1f555",
"unicode_alternates" : "",
- "name" : "clock face six oclock",
+ "name" : "clock face six o'clock",
"shortname" : ":clock6:",
"category" : "symbols",
"emoji_order" : "1018",
"clock7" : {
"unicode" : "1f556",
"unicode_alternates" : "",
- "name" : "clock face seven oclock",
+ "name" : "clock face seven o'clock",
"shortname" : ":clock7:",
"category" : "symbols",
"emoji_order" : "1019",
"clock8" : {
"unicode" : "1f557",
"unicode_alternates" : "",
- "name" : "clock face eight oclock",
+ "name" : "clock face eight o'clock",
"shortname" : ":clock8:",
"category" : "symbols",
"emoji_order" : "1020",
"clock9" : {
"unicode" : "1f558",
"unicode_alternates" : "",
- "name" : "clock face nine oclock",
+ "name" : "clock face nine o'clock",
"shortname" : ":clock9:",
"category" : "symbols",
"emoji_order" : "1021",
"clock10" : {
"unicode" : "1f559",
"unicode_alternates" : "",
- "name" : "clock face ten oclock",
+ "name" : "clock face ten o'clock",
"shortname" : ":clock10:",
"category" : "symbols",
"emoji_order" : "1022",
"clock11" : {
"unicode" : "1f55a",
"unicode_alternates" : "",
- "name" : "clock face eleven oclock",
+ "name" : "clock face eleven o'clock",
"shortname" : ":clock11:",
"category" : "symbols",
"emoji_order" : "1023",
"clock12" : {
"unicode" : "1f55b",
"unicode_alternates" : "",
- "name" : "clock face twelve oclock",
+ "name" : "clock face twelve o'clock",
"shortname" : ":clock12:",
"category" : "symbols",
"emoji_order" : "1024",
-/* gtkaccessibleattributeset.c: Accessible attribute containt
+/* gtkaccessibleattributeset.c: Accessible attribute content
*
* Copyright 2020 GNOME Foundation
*
{
GtkApplicationImplDBusClass parent_class;
- /* stores the dbus version of the overriden methods */
+ /* stores the dbus version of the overridden methods */
guint (*dbus_inhibit) (GtkApplicationImpl *impl,
GtkWindow *window,
GtkApplicationInhibitFlags flags,
* sets up an action with the name win.show-help-overlay to present
* it.
*
- * @window takes resposibility for destroying @help_overlay.
+ * @window takes responsibility for destroying @help_overlay.
*/
void
gtk_application_window_set_help_overlay (GtkApplicationWindow *window,
* @obey_child: If %TRUE, @ratio is ignored, and the aspect
* ratio is taken from the requistion of the child.
*
- * Sets whether the aspect ratio of the childs size
+ * Sets whether the aspect ratio of the child's size
* request should override the set aspect ratio of
* the #GtkAspectFrame.
*/
* gtk_aspect_frame_get_obey_child:
* @self: a #GtkAspectFrame
*
- * Returns whether the childs size request should override
+ * Returns whether the child's size request should override
* the set aspect ratio of the #GtkAspectFrame.
*
- * Returns: whether to obey the childs size request
+ * Returns: whether to obey the child's size request
*/
gboolean
gtk_aspect_frame_get_obey_child (GtkAspectFrame *self)
* @last: last value to add
*
* Adds the closed range [@first, @last], so @first, @last and all
- * values inbetween. @first must be smaller than @last.
+ * values in between. @first must be smaller than @last.
**/
void
gtk_bitset_add_range_closed (GtkBitset *self,
* @last: last value to remove
*
* Removes the closed range [@first, @last], so @first, @last and all
- * values inbetween. @first must be smaller than @last.
+ * values in between. @first must be smaller than @last.
**/
void
gtk_bitset_remove_range_closed (GtkBitset *self,
*
* Files will be added to @self from time to time while loading is
* going on. The order in which are added is undefined and may change
- * inbetween runs.
+ * in between runs.
*
* Returns: %TRUE if @self is loading
*/
/**
* GtkBoolFilter:expression: (type GtkExpression)
*
- * The boolean expression to evalute on item
+ * The boolean expression to evaluate on item
*/
properties[PROP_EXPRESSION] =
gtk_param_spec_expression ("expression",
* %NULL for none
*
* Sets the current object for the @builder. The current object can be
- * tought of as the `this` object that the builder is working for and
+ * thought of as the `this` object that the builder is working for and
* will often be used as the default object when an object is optional.
*
* gtk_widget_init_template() for example will set the current object to
{
RequiresInfo *req_info = state_pop_info (data, RequiresInfo);
- /* TODO: Allow third party widget developers to check thier
+ /* TODO: Allow third party widget developers to check their
* required versions, possibly throw a signal allowing them
- * to check thier library versions here.
+ * to check their library versions here.
*/
if (!strcmp (req_info->library, "gtk+"))
{
*
* # Rendering Areas
*
- * Once area sizes have been aquired at least for the rows in the
+ * Once area sizes have been acquired at least for the rows in the
* visible area of the layouting widget they can be rendered at
* #GtkWidgetClass.snapshot() time.
*
int *minimum_height,
int *natural_height)
{
- /* If the area doesnt do height-for-width, fallback on base preferred height */
+ /* If the area doesn't do height-for-width, fallback on base preferred height */
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_height (area, context, widget, minimum_height, natural_height);
}
int *minimum_width,
int *natural_width)
{
- /* If the area doesnt do width-for-height, fallback on base preferred width */
+ /* If the area doesn't do width-for-height, fallback on base preferred width */
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_width, natural_width);
}
}
else
{
- /* If the cell we are rendering doesnt fit into the remaining space,
+ /* If the cell we are rendering doesn't fit into the remaining space,
* clip it so that the underlying renderer has a chance to deal with
* it (for instance text renderers get a chance to ellipsize).
*/
* @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
* @natural_size: (out) (allow-none): location to store the natural size, or %NULL
*
- * Retreives a renderer’s natural size when rendered to @widget.
+ * Retrieves a renderer’s natural size when rendered to @widget.
*/
void
gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell,
* @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
* @natural_size: (out) (allow-none): location to store the natural size, or %NULL
*
- * Retreives a renderer’s natural size when rendered to @widget.
+ * Retrieves a renderer’s natural size when rendered to @widget.
*/
void
gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell,
* @minimum_width: (out) (allow-none): location for storing the minimum size, or %NULL
* @natural_width: (out) (allow-none): location for storing the preferred size, or %NULL
*
- * Retreives a cell renderers’s minimum and natural width if it were rendered to
+ * Retrieves a cell renderers’s minimum and natural width if it were rendered to
* @widget with the specified @height.
*/
void
* @minimum_height: (out) (allow-none): location for storing the minimum size, or %NULL
* @natural_height: (out) (allow-none): location for storing the preferred size, or %NULL
*
- * Retreives a cell renderers’s minimum and natural height if it were rendered to
+ * Retrieves a cell renderers’s minimum and natural height if it were rendered to
* @widget with the specified @width.
*/
void
* Sets the height of a renderer to explicitly be determined by the “font” and
* “y_pad” property set on it. Further changes in these properties do not
* affect the height, so they must be accompanied by a subsequent call to this
- * function. Using this function is unflexible, and should really only be used
+ * function. Using this function is inflexible, and should really only be used
* if calculating the size of a cell is too slow (ie, a massive number of cells
* displayed). If @number_of_rows is -1, then the fixed height is unset, and
* the height is determined by the properties again.
* height-for-width and not the opposite. Here we have only to return
* the height for the base minimum width of the renderer.
*
- * Note this code path wont be followed by GtkTreeView which is
+ * Note this code path won't be followed by GtkTreeView which is
* height-for-width specifically.
*/
gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, NULL);
* and #GtkCellAreaContext. A #GtkCellAreaContext can be provided to the
* #GtkCellView at construction time in order to keep the cellview in context
* of a group of cell views, this ensures that the renderers displayed will
- * be properly aligned with eachother (like the aligned cells in the menus
+ * be properly aligned with each other (like the aligned cells in the menus
* of #GtkComboBox).
*
* #GtkCellView is #GtkOrientable in order to decide in which orientation
*
* Whether the view should request enough space to always fit
* the size of every row in the model (used by the combo box to
- * ensure the combo box size doesnt change when different items
+ * ensure the combo box size doesn't change when different items
* are selected).
*
* since 3.0
* Creates a new #GtkCellView widget with a specific #GtkCellArea
* to layout cells and a specific #GtkCellAreaContext.
*
- * Specifying the same context for a handfull of cells lets
+ * Specifying the same context for a handful of cells lets
* the underlying area synchronize the geometry for those cells,
* in this way alignments with cellviews for other rows are
* possible.
GtkWidget *widget = GTK_WIDGET (self);
gtk_widget_set_focusable (widget, FALSE);
- /* FIXME: Figure out if settting the manager class to INVALID should work */
+ /* FIXME: Figure out if setting the manager class to INVALID should work */
gtk_widget_set_layout_manager (widget, NULL);
widget->priv->resize_func = gtk_column_view_cell_resize_func;
}
* @title: (nullable): Title to use for this column
*
* Sets the title of this column. The title is displayed in the header of a
- * #GtkColumnView for this column and is therefor user-facing text that should
+ * #GtkColumnView for this column and is therefore user-facing text that should
* be translated.
*/
void
* @first: a #GtkConstraintVariable
* @second: a #GtkConstraintVariable
*
- * Creates a new #GtkConstraintVariablePair, containint @first and @second.
+ * Creates a new #GtkConstraintVariablePair, containing @first and @second.
*
* The #GtkConstraintVariablePair acquires a reference over the two
* given #GtkConstraintVariables.
* implementing shorthand properties. A successful parse of an image
* can not be guaranteed.
*
- * Returns: %TURE if it looks like an image.
+ * Returns: %TRUE if it looks like an image.
**/
gboolean
_gtk_css_image_can_parse (GtkCssParser *parser)
* - The sibling ordering in the CSS node tree is supposed to correspond
* to the visible order of content: top-to-bottom and left-to-right.
* Reorder your nodes to maintain this correlation. In particular for
- * horizontally layed out widgets, this will require listening to
+ * horizontally laid out widgets, this will require listening to
* ::direction-changed.
* - The draw function should just use gtk_style_context_save_to_node() to
* 'switch' to the right node, not make any other changes to the style
_gtk_css_value_equal0 (const GtkCssValue *value1,
const GtkCssValue *value2)
{
- /* Inclues both values being NULL */
+ /* Includes both values being NULL */
if (value1 == value2)
return TRUE;
*
* The default IO priority is %G_PRIORITY_DEFAULT, which is higher than
* the GTK redraw priority. If you are loading a lot of directories in
- * parrallel, lowering it to something like %G_PRIORITY_DEFAULT_IDLE
+ * parallel, lowering it to something like %G_PRIORITY_DEFAULT_IDLE
* may increase responsiveness.
*/
void
*
* Files will be added to @self from time to time while loading is
* going on. The order in which are added is undefined and may change
- * inbetween runs.
+ * in between runs.
*
* Returns: %TRUE if @self is loading
*/
* have changed. gtk_expression_watch() starts watching an expression, and
* gtk_expression_watch_unwatch() stops.
*
- * Watches can be created for automatically updating the propery of an object,
+ * Watches can be created for automatically updating the property of an object,
* similar to GObject's #GBinding mechanism, by using gtk_expression_bind().
*
* # GtkExpression in GObject properties
* @chooser: a #GtkFileChooser
* @create_folders: %TRUE if the Create Folder button should be displayed
*
- * Sets whether file choser will offer to create new folders.
+ * Sets whether file chooser will offer to create new folders.
* This is only relevant if the action is not set to be
* %GTK_FILE_CHOOSER_ACTION_OPEN.
**/
* gtk_file_chooser_get_create_folders:
* @chooser: a #GtkFileChooser
*
- * Gets whether file choser will offer to create new folders.
+ * Gets whether file chooser will offer to create new folders.
* See gtk_file_chooser_set_create_folders().
*
* Returns: %TRUE if the Create Folder button should be displayed.
error_dialog (impl, _("The file could not be renamed"), error);
else
{
- /* Rename succeded, save renamed file so it will
+ /* Rename succeeded, save renamed file so it will
* be revealed by our "row-changed" handler */
impl->renamed_file = g_object_ref (child);
}
/* By default flow at the natural item width */
line_length = avail_size / (nat_item_size + item_spacing);
- /* After the above aproximation, check if we cant fit one more on the line */
+ /* After the above approximation, check if we can't fit one more on the line */
if (line_length * item_spacing + (line_length + 1) * nat_item_size <= avail_size)
line_length++;
if (line_align != GTK_ALIGN_FILL)
line_size = MIN (line_size, nat_fixed_line_size);
- /* Get the real extra pixels incase of GTK_ALIGN_START lines */
+ /* Get the real extra pixels in case of GTK_ALIGN_START lines */
extra_pixels = avail_size - (line_length - 1) * item_spacing - item_size * line_length;
extra_line_pixels = avail_other_size - (n_lines - 1) * line_spacing - line_size * n_lines;
}
nat_width += nat_line_length;
}
}
- else /* In homogeneous mode; horizontally oriented boxs
+ else /* In homogeneous mode; horizontally oriented boxes
* give the same width to all children */
{
get_max_item_size (box, GTK_ORIENTATION_HORIZONTAL,
/* By default flow at the natural item width */
line_length = avail_size / (nat_item_height + priv->row_spacing);
- /* After the above aproximation, check if we cant fit one more on the line */
+ /* After the above approximation, check if we can't fit one more on the line */
if (line_length * priv->row_spacing + (line_length + 1) * nat_item_height <= avail_size)
line_length++;
/* By default flow at the natural item width */
line_length = avail_size / (nat_item_width + priv->column_spacing);
- /* After the above aproximation, check if we cant fit one more on the line */
+ /* After the above approximation, check if we can't fit one more on the line */
if (line_length * priv->column_spacing + (line_length + 1) * nat_item_width <= avail_size)
line_length++;
/**
* GtkFlowBox::selected-children-changed:
- * @box: the #GtkFlowBox on wich the signal is emitted
+ * @box: the #GtkFlowBox on which the signal is emitted
*
* The ::selected-children-changed signal is emitted when the
* set of selected children changes.
}
}
-/* Buildable implemenation {{{3 */
+/* Buildable implementation {{{3 */
static GtkBuildableIface *parent_buildable_iface;
* to gtk_frame_new().)
*
* Returns: (nullable): the text in the label, or %NULL if there
- * was no label widget or the lable widget was not
+ * was no label widget or the label widget was not
* a #GtkLabel. This string is owned by GTK+ and
* must not be modified or freed.
**/
*
* The number of touches that a #GtkGesture need to be recognized is controlled
* by the #GtkGesture:n-points property, if a gesture is keeping track of less
- * or more than that number of sequences, it won't check wether the gesture
+ * or more than that number of sequences, it won't check whether the gesture
* is recognized.
*
* As soon as the gesture has the expected number of touches, it will check
* @See_also: #GtkGestureSwipe
*
* #GtkGestureDrag is a #GtkGesture implementation that recognizes drag
- * operations. The drag operation itself can be tracked throught the
+ * operations. The drag operation itself can be tracked throughout the
* #GtkGestureDrag::drag-begin, #GtkGestureDrag::drag-update and
* #GtkGestureDrag::drag-end signals, or the relevant coordinates be
* extracted through gtk_gesture_drag_get_offset() and
*
* Ensures that the @area framebuffer object is made the current draw
* and read target, and that all the required buffers for the @area
- * are created and bound to the frambuffer.
+ * are created and bound to the framebuffer.
*
* This function is automatically called before emitting the
* #GtkGLArea::render signal, and doesn't normally need to be called
* If set to %FALSE the data from previous rendering is kept around and will
* be used for drawing the widget the next time, unless the window is resized.
* In order to force a rendering gtk_gl_area_queue_render() must be called.
- * This mode is useful when the scene changes seldomly, but takes a long time
+ * This mode is useful when the scene changes seldom, but takes a long time
* to redraw.
*/
obj_props[PROP_AUTO_RENDER] =
* around and will be used for drawing the widget the next time,
* unless the window is resized. In order to force a rendering
* gtk_gl_area_queue_render() must be called. This mode is useful when
- * the scene changes seldomly, but takes a long time to redraw.
+ * the scene changes seldom, but takes a long time to redraw.
*/
void
gtk_gl_area_set_auto_render (GtkGLArea *area,
* @y into the primary direction.
*
* If y is larger than the height of all cells, %NULL will be returned.
- * In particular that means that for an emtpy grid, %NULL is returned
+ * In particular that means that for an empty grid, %NULL is returned
* for any value.
*
* Returns: (nullable): The first cell at offset y or %NULL if none
if (g_stat (cache_filename, &st) < 0 || st.st_size < 4)
goto done;
- /* Verify cache is uptodate */
+ /* Verify cache is up-to-date */
if (st.st_mtime < path_st.st_mtime)
{
GTK_NOTE (ICONTHEME, g_message ("icon cache outdated"));
* All private functions that take a GtkIconTheme (or one of its
* private data types (like IconThemeDir, UnthemedIcon, etc) arg are
* expected to be called with the icon theme lock held, unless the
- * funcion has a _unlocked suffix. Any similar function that must be
+ * function has a _unlocked suffix. Any similar function that must be
* called on the main thread, will have a _mainthread suffix.
*
* So the rules for such functions are:
* we finalize on a thread and on the main thread some display or
* setting signal is emitted.
*
- * It is possible that before we aquire the lock this happens
+ * It is possible that before we acquire the lock this happens
* and the other thread refs the icon theme for some reason, but
* this is ok as it is allowed to resurrect objects in dispose
* (but not in finalize).
* and only invalidate a single item and queue a relayout
* instead of invalidating the whole thing.
*
- * For now GtkIconView still cant deal with huge models
+ * For now GtkIconView still can't deal with huge models
* so just invalidate the whole thing when the model
* changes.
*/
* GtkIconViewDropPosition:
* @GTK_ICON_VIEW_NO_DROP: no drop possible
* @GTK_ICON_VIEW_DROP_INTO: dropped item replaces the item
- * @GTK_ICON_VIEW_DROP_LEFT: droppped item is inserted to the left
+ * @GTK_ICON_VIEW_DROP_LEFT: dropped item is inserted to the left
* @GTK_ICON_VIEW_DROP_RIGHT: dropped item is inserted to the right
* @GTK_ICON_VIEW_DROP_ABOVE: dropped item is inserted above
* @GTK_ICON_VIEW_DROP_BELOW: dropped item is inserted below
static void gtk_image_css_changed (GtkWidget *widget,
GtkCssStyleChange *change);
static void gtk_image_system_setting_changed (GtkWidget *widget,
- GtkSystemSetting seting);
+ GtkSystemSetting setting);
static void gtk_image_finalize (GObject *object);
static void gtk_image_set_property (GObject *object,
if (!GDK_IS_SURFACE (context_ime->client_surface))
return;
- /* swtich current context */
+ /* switch current context */
context_ime->focus = TRUE;
hwnd = gdk_win32_surface_get_impl_hwnd (context_ime->client_surface);
if (!GDK_IS_SURFACE (context_ime->client_surface))
return;
- /* swtich current context */
+ /* switch current context */
context_ime->focus = FALSE;
hwnd = gdk_win32_surface_get_impl_hwnd (context_ime->client_surface);
context_ime->preediting = FALSE;
}
- /* remove event fileter */
+ /* remove event filter */
toplevel = context_ime->client_surface;
if (GDK_IS_SURFACE (toplevel))
{
*
* y'' = -my'
*
- * With m the resistence factor. For this we use the following 2
+ * With m the resistance factor. For this we use the following 2
* base solutions:
*
* f1(x) = 1
*
* GtkLabel has a single CSS node with the name label. A wide variety
* of style classes may be applied to labels, such as .title, .subtitle,
- * .dim-label, etc. In the #GtkShortcutsWindow, labels are used wth the
+ * .dim-label, etc. In the #GtkShortcutsWindow, labels are used with the
* .keycap style class.
*
* If the label has a selection, it gets a subnode with name selection.
/**
* GtkLabel:xalign:
*
- * The xalign property determines the horizontal aligment of the label text
+ * The xalign property determines the horizontal alignment of the label text
* inside the labels size allocation. Compare this to #GtkWidget:halign,
* which determines how the labels size allocation is positioned in the
* space available for the label.
/**
* GtkLabel:yalign:
*
- * The yalign property determines the vertical aligment of the label text
+ * The yalign property determines the vertical alignment of the label text
* inside the labels size allocation. Compare this to #GtkWidget:valign,
* which determines how the labels size allocation is positioned in the
* space available for the label.
selected = gtk_bitset_new_empty ();
mask = gtk_bitset_ref (rubberband_selection);
}
- else /* no modifer */
+ else /* no modifier */
{
/* select the rubberband, clear the rest */
selected = gtk_bitset_ref (rubberband_selection);
/**
* GtkListBox::selected-rows-changed:
- * @box: the #GtkListBox on wich the signal is emitted
+ * @box: the #GtkListBox on which the signal is emitted
*
* The ::selected-rows-changed signal is emitted when the
* set of selected rows changes.
* in process, the GtkMediaStream:seeking property will be set.
*
* When calling gtk_media_stream_seek() during an ongoing seek operation,
- * the new seek wil override any pending seek.
+ * the new seek will override any pending seek.
**/
void
gtk_media_stream_seek (GtkMediaStream *self,
* gtk_show_uri_on_window() is a convenient way to launch applications for URIs.
*
* Another object that is worth mentioning in this context is
- * #GdkAppLaunchContext, which provides visual feedback when lauching
+ * #GdkAppLaunchContext, which provides visual feedback when launching
* applications.
*/
/**
* GtkNumericSorter:expression: (type GtkExpression)
*
- * The expression to evalute on items to get a number to compare with
+ * The expression to evaluate on items to get a number to compare with
*/
properties[PROP_EXPRESSION] =
gtk_param_spec_expression ("expression",
gtk_widget_add_css_class (path_bar->down_slider_button, "slider-button");
gtk_widget_set_parent (path_bar->down_slider_button, GTK_WIDGET (path_bar));
- /* GtkBuilder wont let us connect 'swapped' without specifying the signal's
+ /* GtkBuilder won't let us connect 'swapped' without specifying the signal's
* user data in the .ui file
*/
g_signal_connect_swapped (path_bar->up_slider_button, "clicked",
* is also not true, since when the drag comes from a different widget than the
* sidebar, when the drag stops the last drag signal we receive is drag-leave.
* So here what we will do is restore the state of the sidebar as if no drag
- * is being done (and if the application didnt request for permanent hints with
+ * is being done (and if the application didn't request for permanent hints with
* gtk_places_sidebar_show_drop_hints) and we will free the drag data next time
* we build new drag data in drag_data_received.
*/
* gtk_print_job_get_track_print_status:
* @job: a #GtkPrintJob
*
- * Returns wheter jobs will be tracked after printing.
+ * Returns whether jobs will be tracked after printing.
* For details, see gtk_print_job_set_track_print_status().
*
* Returns: %TRUE if print job status will be reported after printing
gtk_print_settings_set_number_up (print_settings, 1);
gtk_print_settings_set_number_up_layout (print_settings, GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM);
- /* These removals are neccessary because cups-* settings have higher priority
+ /* These removals are necessary because cups-* settings have higher priority
* than normal settings.
*/
gtk_print_settings_unset (print_settings, "cups-reverse");
*
* This must be set to a positive number
* before the rendering starts. It may be set in a
- * #GtkPrintOperation::begin-print signal hander.
+ * #GtkPrintOperation::begin-print signal handler.
*
* Note that the page numbers passed to the
* #GtkPrintOperation::request-page-setup and
*
* This must be set to a positive number
* before the rendering starts. It may be set in a
- * #GtkPrintOperation::begin-print signal hander.
+ * #GtkPrintOperation::begin-print signal handler.
*
* Note that the page numbers passed to the
* #GtkPrintOperation::request-page-setup
* @filename: (type filename): the filename for the exported file
*
* Sets up the #GtkPrintOperation to generate a file instead
- * of showing the print dialog. The indended use of this function
+ * of showing the print dialog. The intended use of this function
* is for implementing “Export to PDF” actions. Currently, PDF
* is the only supported format.
*
if (gtk_property_lookup_list_model_append (self, n_items) == n_items)
{
- /* readd NULL sentinel */
+ /* re-add NULL sentinel */
g_ptr_array_add (self->items, NULL);
}
}
}
/* Returns a new NSImage or %NULL in case of an error.
- * The device scale factor will be transfered to the NSImage (hidpi)
+ * The device scale factor will be transferred to the NSImage (hidpi)
*/
NSImage *
_gtk_quartz_create_image_from_surface (cairo_surface_t *surface)
/**
* gtk_radio_button_join_group:
* @radio_button: the #GtkRadioButton object
- * @group_source: (allow-none): a radio button object whos group we are
+ * @group_source: (allow-none): a radio button object whose group we are
* joining, or %NULL to remove the radio button from its group
*
* Joins a #GtkRadioButton object to the group of another #GtkRadioButton object
* @error: (allow-none): a return location for a #GError, or %NULL
*
* Searches for a URI inside the recently used resources list, and
- * returns a #GtkRecentInfo containing informations about the resource
+ * returns a #GtkRecentInfo containing information about the resource
* like its MIME type, or its display name.
*
* Returns: (nullable): a #GtkRecentInfo containing information
continue;
/* NB: code below divides by this value */
- /* a border smaller than this will not noticably modify
+ /* a border smaller than this will not noticeably modify
* pixels on screen, and since we don't compare with 0,
* we'll use this value */
if (border_width[i] < 1.0 / 1024)
}
/* We request a different size than the child requested scaled by
- * this scale as it will render smaller from the transision.
+ * this scale as it will render smaller from the transition.
* However, we still want to allocate the child widget with its
* unscaled size so it renders right instead of e.g. ellipsizing or
* some other form of clipping. We do this by reverse-applying
* Returns the size of a non-scrolling border around the
* outside of the scrollable. An example for this would
* be treeview headers. GTK+ can use this information to
- * display overlayed graphics, like the overshoot indication,
+ * display overlaid graphics, like the overshoot indication,
* at the right position.
*
* Returns: %TRUE if @border has been set
* the content is pulled beyond the end, and this situation can be
* captured with the #GtkScrolledWindow::edge-overshot signal.
*
- * If no mouse device is present, the scrollbars will overlayed as
+ * If no mouse device is present, the scrollbars will overlaid as
* narrow, auto-hiding indicators over the content. If traditional
* scrollbars are desired although no mouse is present, this behaviour
* can be turned off with the #GtkScrolledWindow:overlay-scrolling
*
* Whether overlay scrolling is enabled or not. If it is, the
* scrollbars are only added as traditional widgets when a mouse
- * is present. Otherwise, they are overlayed on top of the content,
+ * is present. Otherwise, they are overlaid on top of the content,
* as narrow indicators.
*
* Note that overlay scrolling can also be globally disabled, with
* are more likely to implement support for those.
*
* Requests that the selection state of all positions set in @mask be
- * updated to the respecitve value in the @selected bitmask.
+ * updated to the respective value in the @selected bitmask.
*
* In pseudocode, it would look something like this:
*
/**
* GtkSettings:gtk-overlay-scrolling:
*
- * Whether scrolled windows may use overlayed scrolling indicators.
+ * Whether scrolled windows may use overlaid scrolling indicators.
* If this is set to %FALSE, scrolled windows will have permanent
* scrollbars.
*/
void
gtk_sidebar_row_hide (GtkSidebarRow *self,
- gboolean inmediate)
+ gboolean immediate)
{
guint transition_duration;
transition_duration = gtk_revealer_get_transition_duration (GTK_REVEALER (self->revealer));
- if (inmediate)
+ if (immediate)
gtk_revealer_set_transition_duration (GTK_REVEALER (self->revealer), 0);
gtk_revealer_set_reveal_child (GTK_REVEALER (self->revealer), FALSE);
/* Use these methods instead of gtk_widget_hide/show to use an animation */
void gtk_sidebar_row_hide (GtkSidebarRow *self,
- gboolean inmediate);
+ gboolean immediate);
void gtk_sidebar_row_reveal (GtkSidebarRow *self);
GtkWidget *gtk_sidebar_row_get_eject_button (GtkSidebarRow *self);
* properties.
*
* Note that GtkSpinButton will by default make its entry large enough to
- * accomodate the lower and upper bounds of the adjustment. If this is
+ * accommodate the lower and upper bounds of the adjustment. If this is
* not desired, the automatic sizing can be turned off by explicitly
* setting #GtkEditable::width-chars to a value != -1.
*
* I don't know if the positive sign always gets bogusly set to
* a digit when the above Registry value is corrupted as
* described. (In my test case, it got set to "8", and in the
- * bug report above it presumably was set ot "0".) Probably it
+ * bug report above it presumably was set to "0".) Probably it
* might get set to almost anything? So how to distinguish a
* bogus value from some correct one for some locale? That is
* probably hard, but at least we should filter out the
* gtk_stack_get_interpolate_size:
* @stack: A #GtkStack
*
- * Returns wether the #GtkStack is set up to interpolate between
+ * Returns whether the #GtkStack is set up to interpolate between
* the sizes of children on page switch.
*
* Returns: %TRUE if child sizes are interpolated
g_return_val_if_fail (GTK_IS_STATUSBAR (statusbar), 0);
g_return_val_if_fail (context_description != NULL, 0);
- /* we need to preserve namespaces on object datas */
+ /* we need to preserve namespaces on object data */
string = g_strconcat ("gtk-status-bar-context:", context_description, NULL);
id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (statusbar), string));
/**
* GtkStringFilter:expression: (type GtkExpression)
*
- * The expression to evalute on item to get a string to compare with
+ * The expression to evaluate on item to get a string to compare with
*/
properties[PROP_EXPRESSION] =
gtk_param_spec_expression ("expression",
/**
* GtkStringSorter:expression: (type GtkExpression)
*
- * The expression to evalute on item to get a string to compare with
+ * The expression to evaluate on item to get a string to compare with
*/
properties[PROP_EXPRESSION] =
gtk_param_spec_expression ("expression",
* Calling gtk_text_history_begin_irreversible_action() and
* gtk_text_history_end_irreversible_action() can be used to denote a
* section of operations that cannot be undone. This will cause all previous
- * changes tracked by the GtkTextHistory to be discared.
+ * changes tracked by the GtkTextHistory to be discarded.
*/
typedef struct _Action Action;
* Moves @iter to the start of the next line. If the iter is already on the
* last line of the buffer, moves the iter to the end of the current line.
* If after the operation, the iter is at the end of the buffer and not
- * dereferencable, returns %FALSE. Otherwise, returns %TRUE.
+ * dereferenceable, returns %FALSE. Otherwise, returns %TRUE.
*
* Returns: whether @iter can be dereferenced
**/
* i.e. pixels we should wrap to fit inside. */
int screen_width;
- /* width/height of the total logical area being layed out */
+ /* width/height of the total logical area being laid out */
int width;
int height;
* GtkTextTag:underline-rgba:
*
* This property modifies the color of underlines. If not set, underlines
- * will use the forground color.
+ * will use the foreground color.
*
* If #GtkTextTag:underline is set to %PANGO_UNDERLINE_ERROR, an alternate
* color may be applied instead of the foreground. Setting this property
* GtkTextTag:strikethrough-rgba:
*
* This property modifies the color of strikeouts. If not set, strikeouts
- * will use the forground color.
+ * will use the foreground color.
*/
g_object_class_install_property (object_class,
PROP_STRIKETHROUGH_RGBA,
* Information for displaying text with this tag. The information
* belows acts as an override on information specified by lower-priority
* tags. If no value is specified, then the next-lower-priority tag
- * on the text determins the value. The text widget itself provides
+ * on the text determines the value. The text widget itself provides
* defaults if no tag specifies an override.
*/
* we're doing center alignment we align the center of the
* character.
*
- * The differents cases handle on each direction:
+ * The different cases handle on each direction:
* 1. cursor outside of the inner area define by within_margin
* 2. if use_align == TRUE, alignment with xalign and yalign
* 3. scrolling on the edges dependent of with_border
gtk_text_iter_order (&old_start, &old_end);
/* move the front cursor, if the mouse is in front of the selection. Should the
- * cursor however be inside the selection (this happens on tripple click) then we
+ * cursor however be inside the selection (this happens on triple click) then we
* move the side which was last moved (current insert mark) */
if (gtk_text_iter_compare (&cursor, &old_start) <= 0 ||
(gtk_text_iter_compare (&cursor, &old_end) < 0 &&
*
* Adds @child at a fixed coordinate in the #GtkTextView's text window. The
* @xpos and @ypos must be in buffer coordinates (see
- * gtk_text_view_get_iter_location() to conver to buffer coordinates).
+ * gtk_text_view_get_iter_location() to convert to buffer coordinates).
*
* @child will scroll with the text view.
*
GFile *file;
/* Rate limit the updates to not flood the gvfsd-trash when too many changes
- * happenned in a short time.
+ * happened in a short time.
*/
if (monitor->timeout_id > 0)
{
"listitem.toggle-expand", NULL);
#if 0
- /* These can't be implementes yet. */
+ /* These can't be implements yet. */
gtk_widget_class_add_binding (widget_class, GDK_KEY_BackSpace, 0, go_to_parent_row, NULL, NULL);
gtk_widget_class_add_binding (widget_class, GDK_KEY_BackSpace, GDK_CONTROL_MASK, go_to_parent_row, NULL, NULL);
#endif
if (result == GTK_ORDERING_EQUAL)
{
/* We must break ties here because if a ever gets a child,
- * it would need to go right inbetween a and b. */
+ * it would need to go right in between a and b. */
GtkTreeListRowCacheKey *cachea = cache_key_from_key (self, keysa[i]);
GtkTreeListRowCacheKey *cacheb = cache_key_from_key (self, keysb[i]);
if (gtk_tree_list_row_get_position (cachea->row) < gtk_tree_list_row_get_position (cacheb->row))
result = gtk_sorter_compare (self->sorter, obj1, obj2);
/* We must break ties here because if r1 ever gets a child,
- * it would need to go right inbetween r1 and r2. */
+ * it would need to go right in between r1 and r2. */
if (result == GTK_ORDERING_EQUAL)
{
if (gtk_tree_list_row_get_position (r1) < gtk_tree_list_row_get_position (r2))
* or its parents. Usually, having a dependency on the state of any child
* node is not possible, unless references are taken on these explicitly.
* When no such reference exists, no signals may be received for these child
- * nodes (see reference couting rule number 3 in the #GtkTreeModel section).
+ * nodes (see reference counting rule number 3 in the #GtkTreeModel section).
*
* Determining the visibility state of a given node based on the state
* of its child nodes is a frequently occurring use case. Therefore,
* @See_also: #GtkTreeModel
*
* The #GtkTreeStore object is a list model for use with a #GtkTreeView
- * widget. It implements the #GtkTreeModel interface, and consequentially,
+ * widget. It implements the #GtkTreeModel interface, and consequently,
* can use all of the methods available there. It also implements the
* #GtkTreeSortable interface so it can be sorted by the view. Finally,
* it also implements the tree
b_prev = node_b->prev;
b_next = node_b->next;
- /* fix up links if the nodes are next to eachother */
+ /* fix up links if the nodes are next to each other */
if (a_prev == node_b)
a_prev = node_a;
if (a_next == node_b)
/* Initially, before the search window is visible, we pass the event to the
* IM context of the search entry box. If it triggers a commit or a preedit,
- * we then show the search window without loosing tree view focus.
- * If the seach window is already visible, we forward the events to it,
+ * we then show the search window without losing tree view focus.
+ * If the search window is already visible, we forward the events to it,
* keeping the focus on the tree view.
*/
if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
/* Ensure we don't have a dangling pointer to a dead node */
ensure_unprelighted (tree_view);
- /* Cancel editting if we've started */
+ /* Cancel editing if we've started */
gtk_tree_view_stop_editing (tree_view, TRUE);
/* If the cursor row got deleted, move the cursor to the next row */
/**
* GtkTreeViewColumnSizing:
* @GTK_TREE_VIEW_COLUMN_GROW_ONLY: Columns only get bigger in reaction to changes in the model
- * @GTK_TREE_VIEW_COLUMN_AUTOSIZE: Columns resize to be the optimal size everytime the model changes.
+ * @GTK_TREE_VIEW_COLUMN_AUTOSIZE: Columns resize to be the optimal size every time the model changes.
* @GTK_TREE_VIEW_COLUMN_FIXED: Columns are a fixed numbers of pixels wide.
*
* The sizing method the column uses to determine its width. Please note
* Widgets are however free to customize their picking algorithm.
*
* This function is used on the toplevel to determine the widget below
- * the mouse cursor for purposes of hover hilighting and delivering events.
+ * the mouse cursor for purposes of hover highlighting and delivering events.
*
* Returns: (nullable) (transfer none): The widget descendant at the given
* coordinate or %NULL if none.
* excluding the widgets used in client side decorations; there is,
* however, no guarantee that the result will be completely accurate
* because client side decoration may include widgets that depend on
- * the user preferences and that may not be visibile at the time you
+ * the user preferences and that may not be visible at the time you
* call this function.
*
* The dimensions returned by this function are suitable for being
if (gtk_widget_get_root (widget) == GTK_ROOT (iw))
{
- /* Don't hilight things in the inspector window */
+ /* Don't highlight things in the inspector window */
break;
}
return (int32_t)s_a;
}
// handle the leading zeroes, it is messy but it allows us to use the fast
- // _mm_cmpistrm instrinsic safely
+ // _mm_cmpistrm intrinsic safely
int32_t count = 0;
if ((A[0] == 0) || (B[0] == 0)) {
if ((A[0] == 0) && (B[0] == 0)) {
case RUN_CONTAINER_TYPE_CODE:
return run_container_clone((const run_container_t *)container);
case SHARED_CONTAINER_TYPE_CODE:
- printf("shared containers are not cloneable\n");
+ printf("shared containers are not clonable\n");
assert(false);
return NULL;
default:
* if (bitset_container_contains(src_2, key)) {
* dst->array[newcard++] = key;
* }
- * but if the result is unpredictible, the processor generates
+ * but if the result is unpredictable, the processor generates
* many mispredicted branches.
- * Difference can be huge (from 3 cycles when predictible all the way
- * to 16 cycles when unpredictible.
+ * Difference can be huge (from 3 cycles when predictable all the way
+ * to 16 cycles when unpredictable.
* See
* https://github.com/lemire/Code-used-on-Daniel-Lemire-s-blog/blob/master/extra/bitset/c/arraybitsetintersection.c
*/
* all containers of respective type.
*
* <*_data> and <keys> are kept close together because they are not accessed
- * during deserilization. This may reduce IO in case of large mmaped bitmaps.
+ * during deserilization. This may reduce IO in case of large mapped bitmaps.
* All members have their native alignments during deserilization except <header>,
* which is not guaranteed to be aligned by 4 bytes.
*/
/**
* The new container consists of a single run [start,stop).
-* It is required that stop>start, the caller is responsability for this check.
-* It is required that stop <= (1<<16), the caller is responsability for this check.
+* It is required that stop>start, the caller is responsibility for this check.
+* It is required that stop <= (1<<16), the caller is responsibility for this check.
* The cardinality of the created container is stop - start.
* Returns NULL on failure
*/
*/
/* If a conversion occurs, the caller is responsible to free the original
* container and
- * he becomes reponsible to free the new one. */
+ * he becomes responsible to free the new one. */
void *convert_run_to_efficient_container(run_container_t *c,
uint8_t *typecode_after);
// like convert_run_to_efficient_container but frees the old result if needed
/**
* Copies a container, requires a typecode. This allocates new memory, caller
* is responsible for deallocation. If the container is not shared, then it is
- * physically cloned. Sharable containers are not cloneable.
+ * physically cloned. Shareable containers are not clonable.
*/
void *container_clone(const void *container, uint8_t typecode);
These wildcard seems unavoidable, need to investigate.
Wildcards are bad and troublesome, use them with care,
or better, just don't.
- Everytime a wildcard is used a kitten dies, painfully.
+ Every time a wildcard is used a kitten dies, painfully.
*/
spinner:disabled,
@at-root %button_basic_flat,
&.flat {
@include button(undecorated);
- // to avoid adiacent buttons borders clashing when transitioning, the transition on the normal state is set
+ // to avoid adjacent buttons borders clashing when transitioning, the transition on the normal state is set
// to none, while it's added back in the hover state, so the button decoration will fade in on hover, but
// it won't fade out when the pointer leave the button allocation area. To make the transition more evident
// in this case the duration is increased.
}
%needs_attention {
- // the dot is drawn by using two radial gradient, the first one is the actuall dot, the other
+ // the dot is drawn by using two radial gradient, the first one is the actual dot, the other
// simulates the shadow labels and icons normally have in buttons.
animation: needs_attention 150ms ease-in;
}
> trough > slider {
- &:dir(ltr), &:dir(rtl) { // specificity bumb
+ &:dir(ltr), &:dir(rtl) { // specificity bump
&:hover, &:backdrop, &:disabled, &:backdrop:disabled, & {
margin-bottom: -15px;
margin-top: 6px;
-gtk-icon-source: none; // defeats the ugly default handle decoration
border-style: none; // just to be sure
background-color: transparent;
- // workaround, using background istead of a border since the border will get rendered twice (?)
+ // workaround, using background instead of a border since the border will get rendered twice (?)
background-image: image($borders_color);
background-size: 1px 1px;
// see https://bugzilla.gnome.org/show_bug.cgi?id=736155 for details.
background-color: transparentize(black, 0.2);
background-clip: padding-box;
- border: 1px solid $tooltip_borders_color; // this suble border is meant to
+ border: 1px solid $tooltip_borders_color; // this subtle border is meant to
// not make the tooltip melt with
// very dark backgrounds
color: white;
@function _button_hilight_color($c) {
//
-// calculate the right top hilight color for buttons
+// calculate the right top highlight color for buttons
//
// $c: base color;
//
// backdrop, backdrop-active, backdrop-insensitive, backdrop-insensitive-active,
// osd, osd-hover, osd-active, osd-insensitive, osd-backdrop, undecorated
//
-// This mixin sets the $button_fill global variable which containts the button background-image
+// This mixin sets the $button_fill global variable which contains the button background-image
//
$_hilight_color: _button_hilight_color($c);
$_button_edge: if($edge == none, none, _widget_edge($edge));
#! /bin/bash
-# This script extracts the typical xgettext invokation out of
+# This script extracts the typical xgettext invocation out of
# po/Makefile.in.in, in order for it to be available as a shell
# command without the need to autogen first. This is needed for
# translation tools such as the damn lies website.
cairo_libs = []
if cc.get_id() == 'msvc'
- # Fallback depedency discovery for those on Visual Studio that do not generate
+ # Fallback dependency discovery for those on Visual Studio that do not generate
# pkg-config files in their build systems for MSVC
# Fallback for Cairo
if not cairo_dep.found()
required_len = g_strv_length (task_data->auth_info_required);
for (i = 0; i < required_len; i++)
{
- /* Not all fields of auth_info are neccessarily written so we can not
+ /* Not all fields of auth_info are necessarily written so we can not
use strfreev here */
g_free (auth_info[i]);
}
return;
}
- /* Prompt successfull, proceed to get or store secret */
+ /* Prompt successful, proceed to get or store secret */
switch (task_data->action)
{
case SECRETS_SERVICE_ACTION_STORE:
break;
case SECRETS_SERVICE_ACTION_QUERY:
- /* Prompt successfull proceed to get secret */
+ /* Prompt successful proceed to get secret */
g_dbus_proxy_call (task_data->item_proxy,
"GetSecret",
g_variant_new ("(o)",
/**
* Direction we should be polling the http socket on.
- * We are either reading or writting at each state.
+ * We are either reading or writing at each state.
* This makes it easy for mainloops to connect to poll.
*/
typedef enum
}
/*
- * Create new GtkPrinter from informations included in TXT records.
+ * Create new GtkPrinter from information included in TXT records.
*/
static void
create_cups_printer_from_avahi_data (AvahiConnectionTestData *data)
error = NULL;
GTK_NOTE (PRINTING,
- g_print ("FILE Backend: Writting %u byte chunk to temp file\n", length));
+ g_print ("FILE Backend: Writing %u byte chunk to temp file\n", length));
while (length > 0)
{
if (error != NULL)
{
GTK_NOTE (PRINTING,
- g_print ("FILE Backend: Error writting to temp file, %s\n", error->message));
+ g_print ("FILE Backend: Error writing to temp file, %s\n", error->message));
g_error_free (error);
}
}
GTK_NOTE (PRINTING,
- g_print ("FILE Backend: Writting %"G_GSIZE_FORMAT" byte chunk to target file\n", bytes_read));
+ g_print ("FILE Backend: Writing %"G_GSIZE_FORMAT" byte chunk to target file\n", bytes_read));
return TRUE;
}
error = NULL;
GTK_NOTE (PRINTING,
- g_print ("LPR Backend: Writting %i byte chunk to temp file\n", length));
+ g_print ("LPR Backend: Writing %i byte chunk to temp file\n", length));
while (length > 0)
{
if (error != NULL)
{
GTK_NOTE (PRINTING,
- g_print ("LPR Backend: Error writting to temp file, %s\n", error->message));
+ g_print ("LPR Backend: Error writing to temp file, %s\n", error->message));
g_error_free (error);
return CAIRO_STATUS_WRITE_ERROR;
}
GTK_NOTE (PRINTING,
- g_print ("LPR Backend: Writting %" G_GSIZE_FORMAT " byte chunk to lpr pipe\n", bytes_read));
+ g_print ("LPR Backend: Writing %" G_GSIZE_FORMAT " byte chunk to lpr pipe\n", bytes_read));
return TRUE;
/* Create the 7 points (only x,y coords) used to draw a tooth */
struct point p[7];
- /* Calculate needed sin/cos for varius angles */
+ /* Calculate needed sin/cos for various angles */
sincos(i * 2.0 * G_PI / teeth + da * 0, &s[0], &c[0]);
sincos(i * 2.0 * M_PI / teeth + da * 1, &s[1], &c[1]);
sincos(i * 2.0 * M_PI / teeth + da * 2, &s[2], &c[2]);
priv->LightSourcePosition_location = glGetUniformLocation(program, "LightSourcePosition");
priv->MaterialColor_location = glGetUniformLocation(program, "MaterialColor");
- /* Set the LightSourcePosition uniform which is constant throught the program */
+ /* Set the LightSourcePosition uniform which is constant throughout the program */
glUniform4fv(priv->LightSourcePosition_location, 1, priv->LightSourcePosition);
/* make the gears */
gtk_window_set_title (GTK_WINDOW (window), "Background Area");
- label = gtk_label_new ("In this example, row spacing gets devided into the background area, "
+ label = gtk_label_new ("In this example, row spacing gets divided into the background area, "
"column spacing is added between each background area, item_padding is "
"prepended space distributed to the background area.");
gtk_label_set_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_vexpand (text_view, TRUE);
gtk_box_append (GTK_BOX (vbox), text_view);
- button = gtk_check_button_new_with_label ("Inhibit system keyboard shorcuts");
+ button = gtk_check_button_new_with_label ("Inhibit system keyboard shortcuts");
gtk_box_append (GTK_BOX (vbox), button);
g_signal_connect (G_OBJECT (button), "toggled",
{
{
"zoom-fit-best",
- "Thats the\n"
+ "That's the\n"
"perfect fit",
"Now fitting foo into bar using frobnicator",
"using his nifty wide angle lense, he was able to catch a 'dark salmon', it was no flying pig "
"format-text-underline",
"Under the\n"
"line",
- "Now underlining that this demo would look alot niftier with some real content",
+ "Now underlining that this demo would look a lot niftier with some real content",
"it was indeed strange to catch a red salmon while fishing for pigs in the deep sky blue.",
"deep sky blue",
99,
"folder",
"The directory",
"Currently scanning your directories.",
- "jill didnt know what to make of the barking pigs either so she fed him sleeping pills",
+ "jill didn't know what to make of the barking pigs either so she fed him sleeping pills",
"brown",
20,
directory_entries
"Now deleting\n"
"the whole thing",
"Time to delete the sucker",
- "and he decided to just delete the whole conversation since it didnt make sense to him",
+ "and he decided to just delete the whole conversation since it didn't make sense to him",
"dark orange",
26,
NULL
if (n >= 20)
{
- const char *names[10] = { NULL, NULL, "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eighty", "ninety" };
+ const char *names[10] = { NULL, NULL, "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
if (s->len)
g_string_append_c (s, ' ');
g_string_append (s, names [n / 10]);
if (n >= 20)
{
- const char *names[10] = { NULL, NULL, "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eighty", "ninety" };
+ const char *names[10] = { NULL, NULL, "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
if (s->len)
g_string_append_c (s, ' ');
g_string_append (s, names [n / 10]);
4) gtk_widget_show() it and take a snapshot image of its contents into
a cairo surface.
5) Compare the two images to be bitwise identical. If they are not, a
- diff image will be created hilighting the differences.
+ diff image will be created highlighting the differences.
6) Save the images as png files to the output directory named:
- test.out.png (rendering of test.ui)
- test.ref.png (rendering of test.ref.ui)
-@define-color nonexistant @idonotexist;
+@define-color nonexistent @idonotexist;
@define-color self @self;
@define-color cycle2 @cycle1;
.background {
- background: linear-gradient(to bottom, @nonexistant, @self, @cycle, @undefinedcolor);
+ background: linear-gradient(to bottom, @nonexistent, @self, @cycle, @undefinedcolor);
}
}
button {
- /* using a nonexistant color because that will lead to the default value */
+ /* using a nonexistent color because that will lead to the default value */
border-color: @doesnotexist;
color: purple;
}
@import url("reset-to-defaults.css");
-/* One caveat that apply to cairo gradients, and make things therefor
+/* One caveat that apply to cairo gradients, and make things therefore
* untestable:
* The start and end points must be identical when drawing
* This means that you cannot:
box {
background-color: @doesntexist;
- box-shadow: @nonexistant 5px 5px;
+ box-shadow: @nonexistent 5px 5px;
border-image: linear-gradient(to top, @notaavailable, @whatever);
}
projects / gtk4.git / commitdiff